home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / libs / intuisup.lha / Intuisup / source.lha / Editor / edit2.c < prev    next >
C/C++ Source or Header  |  1992-10-05  |  17KB  |  733 lines
  1. /* $Revision Header *** Header built automatically - do not edit! ***********
  2.  *
  3.  *    (C) Copyright 1991 by Torsten Jürgeleit
  4.  *
  5.  *    Name .....: edit2.c
  6.  *    Created ..: Sunday 22-Dec-91 21:22:22
  7.  *    Revision .: 2
  8.  *
  9.  *    Date        Author                 Comment
  10.  *    =========   ====================   ====================
  11.  *    02-Oct-92   Michael Bjerking       New realese, better Screen/Window editor
  12.  *    31-Dec-91   Torsten Jürgeleit      new font management
  13.  *    22-Dec-91   Torsten Jürgeleit      Created this file!
  14.  *
  15.  ****************************************************************************
  16.  *
  17.  *    Edit ISUP objects - part 2
  18.  *
  19.  * $Revision Header ********************************************************/
  20.  
  21.  /* Includes */
  22.  
  23. #include "includes.h"
  24. #include "defines.h"
  25. #include "imports.h"
  26. #include "protos.h"
  27.  
  28.  /* Defines */
  29.  
  30. #define EDIT_MODE_NORMAL    1
  31. #define EDIT_MODE_SPECIAL    2
  32.  
  33.  /* Defines */
  34.  
  35. #define EDIT_TITLE_LEFT_EDGE    0
  36. #define EDIT_TITLE_TOP_EDGE    5
  37. #define EDIT_TITLE_TYPE        TEXT_DATA_TYPE_TEXT
  38. #define EDIT_TITLE_FLAGS    (TEXT_DATA_FLAG_CENTER | TEXT_DATA_FLAG_BOLD)
  39. #define EDIT_TITLE_TEXT_ATTR    &topaz80_attr
  40.  
  41.  /* Edit template data */
  42.  
  43. SHORT
  44. edit_template_data_action(struct Template * old_tp, APTR normal_gl,
  45.                           APTR special_gl1, APTR special_gl2, APTR edit_gl)
  46. {
  47.     struct TemplateList *tl = &template_list;
  48.     struct Template *new_tp;
  49.     SHORT status = EDITOR_STATUS_NORMAL;
  50.  
  51.     /* Make clone of selected template and remove it from template list */
  52.     if (!(new_tp = clone_template(tl, old_tp, TRUE)))
  53.     {
  54.         status = EDITOR_ERROR_OUT_OF_MEM;
  55.     }
  56.     else
  57.     {
  58.         struct Template *pred_tp;
  59.         struct MsgPort *up = ewin->UserPort;
  60.         USHORT mode = EDIT_MODE_NORMAL, new_mode = EDIT_MODE_NORMAL;
  61.         BOOL exit = FALSE;
  62.  
  63.         /* Save previous template for Insert() and remove old template from list */
  64.         pred_tp = get_pred(&old_tp->tp_Node);
  65.         Remove(&old_tp->tp_Node);
  66.  
  67.         /* Outer loop */
  68.         do
  69.         {
  70.             BYTE title[80];
  71.             BOOL keepon = TRUE;
  72.  
  73.             /* Init title text */
  74.             switch (TEMPLATE_GROUP(old_tp))
  75.             {
  76.             case TEMPLATE_GROUP_BORDER:
  77.                 strcpy(&title[0], "Edit Border Data");
  78.                 break;
  79.  
  80.             case TEMPLATE_GROUP_TEXT:
  81.                 strcpy(&title[0], "Edit Text Data");
  82.                 break;
  83.  
  84.             case TEMPLATE_GROUP_GADGET:
  85.                 if (mode == EDIT_MODE_NORMAL)
  86.                 {
  87.                     sprintf(&title[0], "Edit normal %s Gadget Data",
  88.                             template_type_text_array[old_tp->tp_Type]);
  89.                 }
  90.                 else
  91.                 {
  92.                     sprintf(&title[0], "Edit special %s Gadget Data",
  93.                             template_type_text_array[old_tp->tp_Type]);
  94.                 }
  95.                 break;
  96.             }
  97.  
  98.             /* Init edit display */
  99.             IClearWindow(eri, ewin, 0, 0, EDITOR_WINDOW_WIDTH,
  100.                          EDITOR_WINDOW_HEIGHT, 0);
  101.             IPrintText(eri, ewin, &title[0], EDIT_TITLE_LEFT_EDGE,
  102.                        EDIT_TITLE_TOP_EDGE, EDIT_TITLE_TYPE, EDIT_TITLE_FLAGS,
  103.                        EDIT_TITLE_TEXT_ATTR);
  104.             if (mode == EDIT_MODE_NORMAL)
  105.             {
  106.                 IDisplayGadgets(ewin, normal_gl);
  107.             }
  108.             else
  109.             {
  110.                 if (special_gl1)
  111.                 {
  112.                     ISetGadgetAttributes(special_gl1, 0, 0L, 0L, USE_CURRENT_VALUE,
  113.                                          USE_CURRENT_VALUE, &new_tp->tp_TextList);
  114.                     change_text_list_editor_mode(special_gl1, DEFAULT_LIST_MODE);
  115.                     IDisplayGadgets(ewin, special_gl1);
  116.                 }
  117.                 if (special_gl2)
  118.                 {
  119.                     IDisplayGadgets(ewin, special_gl2);
  120.                 }
  121.             }
  122.             IDisplayGadgets(ewin, edit_gl);
  123.  
  124.             /* Inner loop */
  125.             do
  126.             {
  127.                 struct IntuiMessage *msg;
  128.  
  129.                 WaitPort(up);
  130.                 while (msg = IGetMsg(up))
  131.                 {
  132.                     APTR gl;
  133.                     USHORT entry;
  134.                     ULONG value;
  135.  
  136.                     switch (msg->Class)
  137.                     {
  138.                     case CLOSEWINDOW:
  139.                         status = EDITOR_STATUS_QUIT;
  140.                         keepon = FALSE;
  141.                         exit = TRUE;
  142.                         break;
  143.  
  144.                     case ISUP_ID:
  145.                         gl = (APTR) msg->SpecialLink;
  146.                         entry = msg->Code;
  147.                         value = (ULONG) msg->IAddress;
  148.                         if (gl == edit_gl)
  149.                         {
  150.                             struct Template *swap_tp;
  151.  
  152.                             /* Perform edit gadget action */
  153.                             switch (entry)
  154.                             {
  155.                             case EDIT_GADGET_OK:
  156.                                 exit = TRUE;
  157.                                 break;
  158.  
  159.                             case EDIT_GADGET_DEFAULT:
  160.                                 free_template_data(tl, new_tp);
  161.                                 if ((status = init_default_template_data(tl,
  162.                                                                          new_tp, TRUE)) != EDITOR_STATUS_NORMAL)
  163.                                 {
  164.                                     swap_tp = old_tp;
  165.                                     old_tp = new_tp;
  166.                                     new_tp = swap_tp;
  167.                                 }
  168.                                 else
  169.                                 {
  170.                                     tl->tl_Flags |= TEMPLATE_LIST_FLAG_CHANGED;
  171.                                 }
  172.                                 exit = TRUE;
  173.                                 break;
  174.  
  175.                             case EDIT_GADGET_SWITCH:
  176.                                 if (mode == EDIT_MODE_NORMAL)
  177.                                 {
  178.                                     new_mode = EDIT_MODE_SPECIAL;
  179.                                 }
  180.                                 else
  181.                                 {
  182.                                     new_mode = EDIT_MODE_NORMAL;
  183.                                 }
  184.                                 break;
  185.  
  186.                             case EDIT_GADGET_CANCEL:
  187.                                 swap_tp = old_tp;
  188.                                 old_tp = new_tp;
  189.                                 new_tp = swap_tp;
  190.                                 exit = TRUE;
  191.                                 break;
  192.                             }
  193.                             keepon = FALSE;
  194.                         }
  195.                         else
  196.                         {
  197.  
  198.                             /* Perform data gadget action */
  199.                             if (mode == EDIT_MODE_NORMAL)
  200.                             {
  201.                                 if ((status = change_normal_template_data(normal_gl,
  202.                                                                           new_tp, entry, value)) !=
  203.                                     EDITOR_STATUS_NORMAL)
  204.                                 {
  205.                                     keepon = FALSE;
  206.                                     exit = TRUE;
  207.                                 }
  208.                             }
  209.                             else
  210.                             {
  211.                                 if (gl = special_gl1)
  212.                                 {
  213.                                     status = perform_text_list_editor_action(special_gl1,
  214.                                                                              new_tp, entry, value);
  215.                                 }
  216.                                 else
  217.                                 {
  218.                                     status = change_special_template_data(special_gl2,
  219.                                                                           new_tp, entry, value);
  220.  
  221.                                 }
  222.                                 if (status != EDITOR_STATUS_NORMAL)
  223.                                 {
  224.                                     keepon = FALSE;
  225.                                     exit = TRUE;
  226.                                 }
  227.                             }
  228.                             tl->tl_Flags |= TEMPLATE_LIST_FLAG_CHANGED;
  229.                         }
  230.                         break;
  231.                     }
  232.                     IReplyMsg(msg);
  233.                 }
  234.             }
  235.             while (keepon == TRUE);
  236.  
  237.             IRemoveGadgets(edit_gl);
  238.             if (mode == EDIT_MODE_NORMAL)
  239.             {
  240.                 IRemoveGadgets(normal_gl);
  241.             }
  242.             else
  243.             {
  244.                 if (special_gl1)
  245.                 {
  246.                     IRemoveGadgets(special_gl1);
  247.                 }
  248.                 if (special_gl2)
  249.                 {
  250.                     IRemoveGadgets(special_gl2);
  251.                 }
  252.             }
  253.             if (new_mode != mode)
  254.             {
  255.                 mode = new_mode;
  256.             }
  257.         }
  258.         while (exit == FALSE);
  259.  
  260.         /* Insert new template in list and free old one */
  261.         Insert((struct List *) & tl->tl_Templates, &new_tp->tp_Node,
  262.                &pred_tp->tp_Node);
  263.         ISetGadgetAttributes(egl, EDITOR_GADGET_TEMPLATES, 0L, 0L,
  264.                              USE_CURRENT_VALUE, USE_CURRENT_VALUE, &tl->tl_Templates);
  265.         free_template(tl, old_tp);
  266.         refresh_all_templates();
  267.     }
  268.     return (status);
  269. }
  270.  
  271.  /* Change normal template data */
  272.  
  273. SHORT
  274. change_normal_template_data(APTR gl, struct Template * tp, USHORT entry,
  275.                             ULONG value)
  276. {
  277.     struct TemplateList *tl = &template_list;
  278.     struct Box *box = &tp->tp_Box;
  279.     struct BorderData *bd;
  280.     struct TextData *td;
  281.     struct GadgetData *gd;
  282.     struct TextAttr *ta;
  283.     BYTE *old_text, buffer[40];
  284.     USHORT old_type, old_pos;
  285.     UWORD old_size;
  286.     SHORT status = EDITOR_STATUS_NORMAL;
  287.  
  288.     switch (TEMPLATE_GROUP(tp))
  289.     {
  290.     case TEMPLATE_GROUP_BORDER:
  291.         bd = &tp->tp_Data.tp_BorderData;
  292.         switch (entry)
  293.         {
  294.         case BORDER_GADGET_NAME:
  295.             strcpy(&tp->tp_TemplateName[0], (BYTE *) value);
  296.             tp->tp_Flags &= ~TEMPLATE_FLAG_DEFAULT_NAME;
  297.             break;
  298.  
  299.         case BORDER_GADGET_TYPE:
  300.             bd->bd_Type = value + 1;
  301.             break;
  302.         }
  303.         break;
  304.  
  305.     case TEMPLATE_GROUP_TEXT:
  306.         gd = &text_gadget_data[TEXT_GADGET_TEXT];
  307.         td = &tp->tp_Data.tp_TextData;
  308.         switch (entry)
  309.         {
  310.         case TEXT_GADGET_NAME:
  311.             strcpy(&tp->tp_TemplateName[0], (BYTE *) value);
  312.             tp->tp_Flags &= ~TEMPLATE_FLAG_DEFAULT_NAME;
  313.             break;
  314.  
  315.         case TEXT_GADGET_TEXT:
  316.             if (td->td_Type == TEXT_DATA_TYPE_TEXT)
  317.             {
  318.                 old_text = td->td_Text;
  319.                 if ((status = duplicate_string((BYTE *) value,
  320.                                                &td->td_Text)) != EDITOR_STATUS_NORMAL)
  321.                 {
  322.                     td->td_Text = old_text;
  323.                 }
  324.                 else
  325.                 {
  326.                     free(old_text);
  327.                 }
  328.             }
  329.             else
  330.             {
  331.                 td->td_Text = (BYTE *) atol((BYTE *) value);
  332.             }
  333.             ISetGadgetAttributes(gl, TEXT_GADGET_TEXT, 0L, 0L,
  334.                                  USE_CURRENT_VALUE, USE_CURRENT_VALUE, td->td_Text);
  335.             break;
  336.  
  337.         case TEXT_GADGET_FONT:
  338.             old_text = (BYTE *) td->td_TextAttr->ta_Name;
  339.             if (!(ta = open_template_font_by_attributes(tl,
  340.                                                         (BYTE *) value, td->td_TextAttr->ta_YSize)))
  341.             {
  342.                 DisplayBeep(NULL);
  343.                 ISetGadgetAttributes(gl, TEXT_GADGET_FONT, 0L, 0L,
  344.                                      USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  345.             }
  346.             else
  347.             {
  348.                 if (ta->ta_YSize != td->td_TextAttr->ta_YSize)
  349.                 {
  350.                     ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L, 0L,
  351.                                          USE_CURRENT_VALUE, USE_CURRENT_VALUE, (VOID *) ta->ta_YSize);
  352.                 }
  353.                 close_template_font(tl, td->td_TextAttr);
  354.                 td->td_TextAttr = ta;
  355.             }
  356.             break;
  357.  
  358.         case TEXT_GADGET_SIZE:
  359.             old_size = td->td_TextAttr->ta_YSize;
  360.             if (!(ta = open_template_font_by_attributes(tl,
  361.                                                         (BYTE *) td->td_TextAttr->ta_Name, (USHORT) value)))
  362.             {
  363.                 DisplayBeep(NULL);
  364.                 ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L, 0L,
  365.                                      USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  366.                                      (VOID *) old_size);
  367.             }
  368.             else
  369.             {
  370.                 if (ta->ta_YSize != value)
  371.                 {
  372.                     ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L, 0L,
  373.                                          USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  374.                                          (VOID *) ta->ta_YSize);
  375.                 }
  376.                 close_template_font(tl, td->td_TextAttr);
  377.                 td->td_TextAttr = ta;
  378.             }
  379.             break;
  380.  
  381.         case TEXT_GADGET_TYPE:
  382.             old_type = td->td_Type;
  383.             old_text = td->td_Text;
  384.             td->td_Type = value + 1;
  385.             gd->gd_Flags &= ~(GADGET_DATA_FLAG_STRING_UNSIGNED_DEC |
  386.                               GADGET_DATA_FLAG_STRING_SIGNED_DEC |
  387.                               GADGET_DATA_FLAG_STRING_HEX |
  388.                               GADGET_DATA_FLAG_STRING_BIN);
  389.             if (td->td_Type == TEXT_DATA_TYPE_TEXT)
  390.             {
  391.                 IConvertUnsignedDec((ULONG) old_text, &buffer[0], 0);
  392.                 if ((status = duplicate_string((BYTE *) & buffer[0],
  393.                                                &td->td_Text)) != EDITOR_STATUS_NORMAL)
  394.                 {
  395.                     td->td_Type = old_type;
  396.                     td->td_Text = old_text;
  397.                 }
  398.             }
  399.             else
  400.             {
  401.                 switch (td->td_Type)
  402.                 {
  403.                 case TEXT_DATA_TYPE_NUM_UNSIGNED_DEC:
  404.                     gd->gd_Flags |= GADGET_DATA_FLAG_STRING_UNSIGNED_DEC;
  405.                     break;
  406.  
  407.                 case TEXT_DATA_TYPE_NUM_SIGNED_DEC:
  408.                     gd->gd_Flags |= GADGET_DATA_FLAG_STRING_SIGNED_DEC;
  409.                     break;
  410.  
  411.                 case TEXT_DATA_TYPE_NUM_HEX:
  412.                     gd->gd_Flags |= GADGET_DATA_FLAG_STRING_HEX;
  413.                     break;
  414.  
  415.                 case TEXT_DATA_TYPE_NUM_BIN:
  416.                     gd->gd_Flags |= GADGET_DATA_FLAG_STRING_BIN;
  417.                     break;
  418.                 }
  419.                 if (old_type == TEXT_DATA_TYPE_TEXT)
  420.                 {
  421.                     td->td_Text = (BYTE *) atol(old_text);
  422.                     free(old_text);
  423.                 }
  424.             }
  425.             ISetGadgetAttributes(gl, TEXT_GADGET_TEXT, 0L, 0L,
  426.                                  USE_CURRENT_VALUE, USE_CURRENT_VALUE, td->td_Text);
  427.             break;
  428.  
  429.         case TEXT_GADGET_BOLD:
  430.             if (value)
  431.             {
  432.                 td->td_Flags |= TEXT_DATA_FLAG_BOLD;
  433.             }
  434.             else
  435.             {
  436.                 td->td_Flags &= ~TEXT_DATA_FLAG_BOLD;
  437.             }
  438.             break;
  439.  
  440.         case TEXT_GADGET_ITALIC:
  441.             if (value)
  442.             {
  443.                 td->td_Flags |= TEXT_DATA_FLAG_ITALIC;
  444.             }
  445.             else
  446.             {
  447.                 td->td_Flags &= ~TEXT_DATA_FLAG_ITALIC;
  448.             }
  449.             break;
  450.  
  451.         case TEXT_GADGET_UNDERLINED:
  452.             if (value)
  453.             {
  454.                 td->td_Flags |= TEXT_DATA_FLAG_UNDERLINED;
  455.             }
  456.             else
  457.             {
  458.                 td->td_Flags &= ~TEXT_DATA_FLAG_UNDERLINED;
  459.             }
  460.             break;
  461.  
  462.         case TEXT_GADGET_COLOR2:
  463.             if (value)
  464.             {
  465.                 td->td_Flags |= TEXT_DATA_FLAG_COLOR2;
  466.             }
  467.             else
  468.             {
  469.                 td->td_Flags &= ~TEXT_DATA_FLAG_COLOR2;
  470.             }
  471.             break;
  472.  
  473.         case TEXT_GADGET_COMPLEMENT:
  474.             if (value)
  475.             {
  476.                 td->td_Flags |= TEXT_DATA_FLAG_COMPLEMENT;
  477.             }
  478.             else
  479.             {
  480.                 td->td_Flags &= ~TEXT_DATA_FLAG_COMPLEMENT;
  481.             }
  482.             break;
  483.         }
  484.  
  485.         /* Calc size of new text for template box */
  486.         box->bo_X2 = box->bo_X1 + IPrintText(pri, pwin, td->td_Text,
  487.                                              td->td_LeftEdge, td->td_TopEdge, td->td_Type,
  488.                                              TEXT_DATA_FLAG_NO_PRINT, td->td_TextAttr) - 1;
  489.         box->bo_Y2 = box->bo_Y1 + td->td_TextAttr->ta_YSize - 1;
  490.         break;
  491.  
  492.     case TEMPLATE_GROUP_GADGET:
  493.         gd = &tp->tp_Data.tp_GadgetData;
  494.         switch (entry)
  495.         {
  496.         case NORMAL_GADGET_NAME:
  497.             strcpy(&tp->tp_TemplateName[0], (BYTE *) value);
  498.             tp->tp_Flags &= ~TEMPLATE_FLAG_DEFAULT_NAME;
  499.             break;
  500.  
  501.         case NORMAL_GADGET_TEXT:
  502.             old_text = gd->gd_Text;
  503.             if ((status = duplicate_string((BYTE *) value,
  504.                                            &gd->gd_Text)) != EDITOR_STATUS_NORMAL)
  505.             {
  506.                 DisplayBeep(NULL);
  507.                 gd->gd_Text = old_text;
  508.                 ISetGadgetAttributes(gl, NORMAL_GADGET_TEXT, 0L, 0L,
  509.                                      USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  510.             }
  511.             else
  512.             {
  513.                 free(old_text);
  514.             }
  515.             break;
  516.  
  517.         case NORMAL_GADGET_FONT:
  518.             old_text = (BYTE *) gd->gd_TextAttr->ta_Name;
  519.             if (!(ta = open_template_font_by_attributes(tl,
  520.                                                         (BYTE *) value, gd->gd_TextAttr->ta_YSize)))
  521.             {
  522.                 DisplayBeep(NULL);
  523.                 ISetGadgetAttributes(gl, TEXT_GADGET_FONT, 0L, 0L,
  524.                                      USE_CURRENT_VALUE, USE_CURRENT_VALUE, old_text);
  525.             }
  526.             else
  527.             {
  528.                 if (ta->ta_YSize != gd->gd_TextAttr->ta_YSize)
  529.                 {
  530.                     ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L, 0L,
  531.                                          USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  532.                                          (VOID *) ta->ta_YSize);
  533.                 }
  534.                 close_template_font(tl, gd->gd_TextAttr);
  535.                 gd->gd_TextAttr = ta;
  536.             }
  537.             break;
  538.  
  539.         case NORMAL_GADGET_SIZE:
  540.             old_size = gd->gd_TextAttr->ta_YSize;
  541.             if (!(ta = open_template_font_by_attributes(tl,
  542.                                                         (BYTE *) gd->gd_TextAttr->ta_Name, (USHORT) value)))
  543.             {
  544.                 DisplayBeep(NULL);
  545.                 ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L, 0L,
  546.                                      USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  547.                                      (VOID *) old_size);
  548.             }
  549.             else
  550.             {
  551.                 if (ta->ta_YSize != value)
  552.                 {
  553.                     ISetGadgetAttributes(gl, TEXT_GADGET_SIZE, 0L, 0L,
  554.                                          USE_CURRENT_VALUE, USE_CURRENT_VALUE,
  555.                                          (VOID *) ta->ta_YSize);
  556.                 }
  557.                 close_template_font(tl, gd->gd_TextAttr);
  558.                 gd->gd_TextAttr = ta;
  559.             }
  560.             break;
  561.  
  562.         case NORMAL_GADGET_POS:
  563.             switch (GADGET_TEXT_POS_MASK(gd->gd_Flags))
  564.             {
  565.             case GADGET_DATA_FLAG_TEXT_LEFT:
  566.                 old_pos = TEXT_POS_LEFT;
  567.                 break;
  568.  
  569.             case GADGET_DATA_FLAG_TEXT_RIGHT:
  570.                 old_pos = TEXT_POS_RIGHT;
  571.                 break;
  572.  
  573.             case GADGET_DATA_FLAG_TEXT_ABOVE:
  574.                 old_pos = TEXT_POS_ABOVE;
  575.                 break;
  576.  
  577.             case GADGET_DATA_FLAG_TEXT_BELOW:
  578.                 old_pos = TEXT_POS_BELOW;
  579.                 break;
  580.  
  581.             default:
  582.                 old_pos = TEXT_POS_INSIDE;
  583.                 break;
  584.             }
  585.  
  586.             /* Check if text position possible for selected gadget type */
  587.             switch (gd->gd_Type)
  588.             {
  589.             case GADGET_DATA_TYPE_MX:
  590.                 if (value != TEXT_POS_LEFT && value != TEXT_POS_RIGHT)
  591.                 {
  592.                     if (old_pos == TEXT_POS_RIGHT)
  593.                     {
  594.                         value = TEXT_POS_LEFT;
  595.                     }
  596.                     else
  597.                     {
  598.                         value = TEXT_POS_RIGHT;
  599.                     }
  600.                 }
  601.                 break;
  602.  
  603.             case GADGET_DATA_TYPE_CHECK:
  604.             case GADGET_DATA_TYPE_STRING:
  605.             case GADGET_DATA_TYPE_INTEGER:
  606.             case GADGET_DATA_TYPE_SLIDER:
  607.             case GADGET_DATA_TYPE_SCROLLER:
  608.             case GADGET_DATA_TYPE_CYCLE:
  609.             case GADGET_DATA_TYPE_COUNT:
  610.                 if (value == TEXT_POS_INSIDE)
  611.                 {
  612.                     if (old_pos == TEXT_POS_BELOW)
  613.                     {
  614.                         value = TEXT_POS_LEFT;
  615.                     }
  616.                     else
  617.                     {
  618.                         value = TEXT_POS_BELOW;
  619.                     }
  620.                 }
  621.                 break;
  622.  
  623.             case GADGET_DATA_TYPE_LISTVIEW:
  624.             case GADGET_DATA_TYPE_PALETTE:
  625.                 if (value != TEXT_POS_ABOVE)
  626.                 {
  627.                     value = TEXT_POS_ABOVE;
  628.                 }
  629.                 break;
  630.  
  631.             default:
  632.                 break;
  633.             }
  634.             ISetGadgetAttributes(gl, NORMAL_GADGET_POS, 0L, 0L,
  635.                                  USE_CURRENT_VALUE, value, (VOID *) USE_CURRENT_VALUE);
  636.             gd->gd_Flags &= ~(GADGET_DATA_FLAG_TEXT_LEFT |
  637.                               GADGET_DATA_FLAG_TEXT_RIGHT |
  638.                               GADGET_DATA_FLAG_TEXT_ABOVE |
  639.                               GADGET_DATA_FLAG_TEXT_BELOW);
  640.             switch (value)
  641.             {
  642.             case TEXT_POS_LEFT:
  643.                 gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_LEFT;
  644.                 break;
  645.  
  646.             case TEXT_POS_RIGHT:
  647.                 gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_RIGHT;
  648.                 break;
  649.  
  650.             case TEXT_POS_ABOVE:
  651.                 gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_ABOVE;
  652.                 break;
  653.  
  654.             case TEXT_POS_BELOW:
  655.                 gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_BELOW;
  656.                 break;
  657.  
  658.             case TEXT_POS_INSIDE:
  659.                 break;
  660.             }
  661.             break;
  662.  
  663.         case NORMAL_GADGET_DISABLED:
  664.             if (value)
  665.             {
  666.                 gd->gd_Flags |= GADGET_DATA_FLAG_DISABLED;
  667.             }
  668.             else
  669.             {
  670.                 gd->gd_Flags &= ~GADGET_DATA_FLAG_DISABLED;
  671.             }
  672.             break;
  673.  
  674.         case NORMAL_GADGET_NO_BORDER:
  675.             if (value)
  676.             {
  677.                 gd->gd_Flags |= GADGET_DATA_FLAG_NO_BORDER;
  678.             }
  679.             else
  680.             {
  681.                 gd->gd_Flags &= ~GADGET_DATA_FLAG_NO_BORDER;
  682.             }
  683.             break;
  684.  
  685.         case NORMAL_GADGET_HIGHCOMP:
  686.             if (value)
  687.             {
  688.                 gd->gd_Flags |= GADGET_DATA_FLAG_HIGH_COMP;
  689.             }
  690.             else
  691.             {
  692.                 gd->gd_Flags &= ~GADGET_DATA_FLAG_HIGH_COMP;
  693.             }
  694.             break;
  695.  
  696.         case NORMAL_GADGET_HOTKEY:
  697.             if (value)
  698.             {
  699.                 gd->gd_Flags |= GADGET_DATA_FLAG_HOTKEY;
  700.             }
  701.             else
  702.             {
  703.                 gd->gd_Flags &= ~GADGET_DATA_FLAG_HOTKEY;
  704.             }
  705.             break;
  706.  
  707.         case NORMAL_GADGET_COLOR2:
  708.             if (value)
  709.             {
  710.                 gd->gd_Flags |= GADGET_DATA_FLAG_TEXT_COLOR2;
  711.             }
  712.             else
  713.             {
  714.                 gd->gd_Flags &= ~GADGET_DATA_FLAG_TEXT_COLOR2;
  715.             }
  716.             break;
  717.         }
  718.         break;
  719.     }
  720.     return (status);
  721. }
  722.  
  723.  /* Change special template data */
  724.  
  725. SHORT
  726. change_special_template_data(APTR gl, struct Template * tp, USHORT entry,
  727.                              ULONG value)
  728. {
  729.     SHORT status = EDITOR_STATUS_NORMAL;
  730.  
  731.     return (status);
  732. }
  733.